#!/usr/bin/env python3
"""
增强的语义分析器
集成机器学习模型和JSON规则引擎

这个模块实现了增强的语义分析器，结合了机器学习模型和JSON规则引擎的优势，
提供更准确和可靠的编程问题类型识别和分析功能。

主要功能：
1. 混合决策策略：结合规则引擎和机器学习模型的预测结果
2. 智能置信度评估：根据多个因素评估预测的可靠性
3. 规则管理：支持动态添加、删除和更新规则
4. 统计分析：提供分析器的使用统计和性能指标
5. 模型管理：支持机器学习模型的加载和切换

技术特点：
- 规则引擎：基于预定义规则的快速匹配
- 机器学习：基于训练数据的智能预测
- 混合策略：结合两种方法的优势
- 容错机制：在模型不可用时自动降级到规则引擎

依赖: ml_trainer, json_rule_engine
"""

import os
import re
from typing import Dict, List, Any, Optional, Tuple
from ml_trainer import MLProblemClassifier
from json_rule_engine import JSONRuleEngine

class EnhancedSemanticAnalyzer:
    """
    增强的语义分析器
    
    这是项目的核心组件，集成了机器学习模型和JSON规则引擎，
    通过混合决策策略提供更准确的问题类型识别和分析。
    
    核心功能：
    1. 混合决策：结合规则引擎和ML模型的预测结果
    2. 智能置信度：评估预测结果的可靠性
    3. 规则管理：动态管理规则库
    4. 统计分析：提供使用统计和性能指标
    5. 模型管理：支持ML模型的加载和切换
    
    使用场景：
    - 编程问题类型识别
    - 测试用例生成
    - 规则库维护
    - 性能分析和优化
    
    注意：这是一个高级组件，需要先配置ML模型和规则引擎。
    """
    
    def __init__(self, ml_model_path: Optional[str] = None, enable_ml: bool = True):
        """
        初始化增强语义分析器
        
        创建分析器实例，加载机器学习模型和JSON规则引擎。
        支持ML模型的动态加载和错误处理。
        
        参数:
            ml_model_path (Optional[str]): 机器学习模型文件路径
                - 如果提供且文件存在，会尝试加载ML模型
                - 如果加载失败，会自动禁用ML功能
            enable_ml (bool): 是否启用机器学习增强功能
                - True: 尝试加载ML模型，失败时降级到规则引擎
                - False: 仅使用规则引擎，不加载ML模型
                
        属性:
            enable_ml (bool): ML功能是否启用
            ml_classifier (MLProblemClassifier): ML分类器实例
            json_rule_engine (JSONRuleEngine): JSON规则引擎实例
            
        异常处理:
            - ML模型加载失败时自动禁用ML功能
            - 规则引擎加载失败时会抛出异常
        """
        self.enable_ml = enable_ml
        self.ml_classifier = None
        
        # 加载机器学习模型 - 如果启用ML且提供了模型路径
        if self.enable_ml and ml_model_path and os.path.exists(ml_model_path):
            try:
                # 创建ML分类器实例
                self.ml_classifier = MLProblemClassifier()
                # 加载训练好的模型
                self.ml_classifier.load_model(ml_model_path)
                print(f"机器学习模型已加载: {ml_model_path}")
            except Exception as e:
                # ML模型加载失败，自动禁用ML功能
                print(f"加载机器学习模型失败: {e}")
                self.ml_classifier = None
                self.enable_ml = False
        
        # 初始化JSON规则引擎 - 这是分析器的核心组件
        self.json_rule_engine = JSONRuleEngine()
    
    def analyze_problem(self, problem_text: str) -> Dict[str, Any]:
        """
        分析编程问题
        
        这是分析器的核心方法，通过混合决策策略分析编程问题：
        1. 使用JSON规则引擎进行基础分析
        2. 如果启用ML，获取ML模型的预测结果
        3. 通过混合决策策略确定最终结果
        4. 返回完整的分析结果
        
        参数:
            problem_text (str): 编程问题的描述文本
                - 支持中英文混合文本
                - 应包含问题的核心描述和要求
                
        返回:
            Dict[str, Any]: 完整的分析结果字典，包含：
                - problem_type: 最终确定的问题类型
                - confidence: 预测的置信度（0-1之间）
                - ml_prediction: ML模型的预测结果
                - ml_confidence: ML预测的置信度
                - rule_prediction: 规则引擎的预测结果
                - rule_confidence: 规则预测的置信度
                - matched_keywords: 匹配的关键词列表
                - matched_patterns: 匹配的模式列表
                - input_format: 输入格式信息
                - output_format: 输出格式信息
                - solution_template: 解决方案模板
                - test_data_generator: 测试数据生成器
                
        工作流程:
            1. 规则引擎分析 → 获取基础预测和置信度
            2. ML模型预测 → 获取ML预测和置信度（如果可用）
            3. 混合决策 → 结合两种预测结果
            4. 结果构建 → 返回完整的分析结果
        """
        # 1. 使用JSON规则引擎进行分析 - 获取基础预测结果
        json_result = self.json_rule_engine.analyze_problem(problem_text)
        
        # 2. 如果启用ML，获取ML预测结果 - 增强预测准确性
        ml_prediction = None
        ml_confidence = 0.0
        
        if self.enable_ml and self.ml_classifier:
            try:
                # 调用ML模型进行预测
                ml_prediction, ml_confidence = self.ml_classifier.predict(problem_text)
            except Exception as e:
                # ML预测失败，记录错误但不影响整体流程
                print(f"ML预测失败: {e}")
                ml_prediction = None
                ml_confidence = 0.0
        
        # 3. 混合决策策略 - 结合规则引擎和ML的预测结果
        final_prediction = self._hybrid_decision(
            json_result.problem_type,      # 规则引擎预测
            json_result.confidence,        # 规则引擎置信度
            ml_prediction,                 # ML预测
            ml_confidence                  # ML置信度
        )
        
        # 4. 构建返回结果 - 包含所有分析信息
        result = {
            "problem_type": final_prediction,           # 最终确定的问题类型
            "confidence": max(json_result.confidence, ml_confidence),  # 最高置信度
            "ml_prediction": ml_prediction,             # ML预测结果
            "ml_confidence": ml_confidence,             # ML置信度
            "rule_prediction": json_result.problem_type, # 规则引擎预测
            "rule_confidence": json_result.confidence,   # 规则引擎置信度
            "matched_keywords": json_result.matched_keywords,     # 匹配的关键词
            "matched_patterns": json_result.matched_patterns,     # 匹配的模式
            "input_format": json_result.input_format,             # 输入格式
            "output_format": json_result.output_format,           # 输出格式
            "solution_template": json_result.solution_template,    # 解决方案模板
            "test_data_generator": json_result.test_data_generator # 测试数据生成器
        }
        
        return result
    
    def _hybrid_decision(self, rule_prediction: str, rule_confidence: float, 
                        ml_prediction: Optional[str], ml_confidence: float) -> str:
        """
        混合决策策略
        
        这是分析器的核心决策逻辑，结合规则引擎和ML模型的预测结果，
        通过智能策略确定最终的问题类型预测。
        
        决策策略：
        1. ML优先：如果ML置信度高（>0.6），优先使用ML结果
        2. 一致性检查：如果ML和规则结果一致，使用ML结果
        3. 置信度比较：不一致时选择置信度更高的结果
        4. 规则降级：ML不可用时使用规则引擎结果
        
        参数:
            rule_prediction (str): 规则引擎的预测结果
            rule_confidence (float): 规则引擎的置信度（0-1）
            ml_prediction (Optional[str]): ML模型的预测结果
            ml_confidence (float): ML模型的置信度（0-1）
            
        返回:
            str: 最终确定的问题类型预测结果
            
        决策逻辑:
            - ML置信度 > 0.6：使用ML结果
            - ML和规则一致：使用ML结果
            - ML和规则不一致：选择置信度更高的
            - ML不可用：使用规则引擎结果
        """
        if self.enable_ml and ml_prediction and ml_confidence > 0.6:
            # ML置信度高，优先使用ML结果
            if ml_confidence > rule_confidence:
                # ML置信度更高，使用ML结果
                return ml_prediction
            else:
                # ML和规则结果一致，使用ML结果
                if ml_prediction == rule_prediction:
                    return ml_prediction
                else:
                    # 不一致时，选择置信度更高的结果
                    return ml_prediction if ml_confidence > rule_confidence else rule_prediction
        else:
            # ML不可用或置信度低，使用规则引擎结果
            return rule_prediction
    
    def get_statistics(self) -> Dict[str, Any]:
        """
        获取分析器统计信息
        
        提供分析器的使用统计和性能指标，包括：
        1. ML功能状态：是否启用和模型是否加载
        2. 规则引擎统计：规则数量、匹配次数等
        3. 性能指标：分析次数、成功率等
        
        返回:
            Dict[str, Any]: 统计信息字典，包含：
                - ml_enabled: ML功能是否启用
                - ml_model_loaded: ML模型是否已加载
                - json_engine_stats: JSON规则引擎的统计信息
        """
        stats = {
            "ml_enabled": self.enable_ml,                    # ML功能状态
            "ml_model_loaded": self.ml_classifier is not None, # ML模型状态
            "json_engine_stats": self.json_rule_engine.get_statistics()  # 规则引擎统计
        }
        return stats
    
    def reload_rules(self):
        """
        重新加载规则
        
        重新加载JSON规则文件，用于规则更新后的刷新。
        这在规则文件被修改后非常有用。
        """
        self.json_rule_engine.reload_rules()
        print("规则已重新加载")
    
    def add_keyword(self, pattern_name: str, keyword: str, weight: int = 5):
        """
        添加关键词到规则引擎
        
        向指定模式添加新的关键词，用于扩展规则库。
        
        参数:
            pattern_name (str): 模式名称
            keyword (str): 要添加的关键词
            weight (int): 关键词权重，默认为5
            
        返回:
            bool: 添加是否成功
        """
        return self.json_rule_engine.add_keyword(pattern_name, keyword, weight)
    
    def remove_keyword(self, pattern_name: str, keyword: str):
        """
        从规则引擎删除关键词
        
        从指定模式中删除关键词，用于规则库维护。
        
        参数:
            pattern_name (str): 模式名称
            keyword (str): 要删除的关键词
            
        返回:
            bool: 删除是否成功
        """
        return self.json_rule_engine.remove_keyword(pattern_name, keyword)
    
    def save_rules(self):
        """
        保存规则到文件
        
        将当前规则保存到JSON文件中，用于持久化存储。
        
        返回:
            bool: 保存是否成功
        """
        return self.json_rule_engine.save_rules()
    
    def extract_keywords_from_text(self, text: str) -> List[Tuple[str, str, int]]:
        """
        从文本中提取关键词
        
        使用规则引擎从文本中提取关键词，返回关键词及其相关信息。
        
        参数:
            text (str): 要分析的文本
            
        返回:
            List[Tuple[str, str, int]]: 关键词列表，每个元素包含：
                - 关键词文本
                - 关键词类型
                - 关键词权重
        """
        return self.json_rule_engine.extract_keywords_from_text(text)
    
    def find_keywords_by_pattern(self, pattern_name: str) -> List[str]:
        """
        根据模式名称查找关键词
        
        查找指定模式下的所有关键词。
        
        参数:
            pattern_name (str): 模式名称
            
        返回:
            List[str]: 该模式下的关键词列表
        """
        return self.json_rule_engine.find_keywords_by_pattern(pattern_name)
    
    def find_patterns_by_keyword(self, keyword: str) -> List[str]:
        """
        根据关键词查找相关模式
        
        查找包含指定关键词的所有模式。
        
        参数:
            keyword (str): 关键词
            
        返回:
            List[str]: 包含该关键词的模式列表
        """
        return self.json_rule_engine.find_patterns_by_keyword(keyword)